/*******************************************************************************
* Copyright (c) 2007, 2008 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.jdt.internal.corext.refactoring;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.ltk.core.refactoring.RefactoringStatus;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IMethod;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.WorkingCopyOwner;
import org.eclipse.jdt.internal.corext.util.Messages;
import org.eclipse.jdt.ui.JavaElementLabels;
public class JavaRefactoringDescriptorUtil {
/* TODO: share implementation with
* org.eclipse.jdt.internal.core.refactoring.descriptors.JavaRefactoringDescriptorUtil
*/
private JavaRefactoringDescriptorUtil(){}
/**
* Predefined argument called <code>element<Number></code>.
* <p>
* This argument should be used to describe the elements being refactored.
* The value of this argument does not necessarily have to uniquely identify
* the elements. However, it must be possible to uniquely identify the
* elements using the value of this argument in conjunction with the values
* of the other user-defined attributes.
* </p>
* <p>
* The element arguments are simply distinguished by appending a number to
* the argument name, e.g. element1. The indices of this argument are non
* zero-based.
* </p>
*/
public static final String ATTRIBUTE_ELEMENT= "element"; //$NON-NLS-1$
/**
* Predefined argument called <code>input</code>.
* <p>
* This argument should be used to describe the element being refactored.
* The value of this argument does not necessarily have to uniquely identify
* the input element. However, it must be possible to uniquely identify the
* input element using the value of this argument in conjunction with the
* values of the other user-defined attributes.
* </p>
*/
public static final String ATTRIBUTE_INPUT= "input"; //$NON-NLS-1$
/**
* Predefined argument called <code>name</code>.
* <p>
* This argument should be used to name the element being refactored. The
* value of this argument may be shown in the user interface.
* </p>
*/
public static final String ATTRIBUTE_NAME= "name"; //$NON-NLS-1$
/**
* Predefined argument called <code>references</code>.
* <p>
* This argument should be used to describe whether references to the
* elements being refactored should be updated as well.
* </p>
*/
public static final String ATTRIBUTE_REFERENCES= "references"; //$NON-NLS-1$
/**
* Predefined argument called <code>selection</code>.
* <p>
* This argument should be used to describe user input selections within a
* text file. The value of this argument has the format "offset length".
* </p>
*/
public static final String ATTRIBUTE_SELECTION= "selection"; //$NON-NLS-1$
/**
* Converts the specified element to an input handle.
*
* @param project
* the project, or <code>null</code> for the workspace
* @param element
* the element
* @return a corresponding input handle
* Note: if the given project is not the element's project, then the full handle is returned
*/
public static String elementToHandle(final String project, final IJavaElement element) {
final String handle= element.getHandleIdentifier();
if (project != null && ! (element instanceof IJavaProject)) {
IJavaProject javaProject= element.getJavaProject();
if (project.equals(javaProject.getElementName())) {
final String id= javaProject.getHandleIdentifier();
return handle.substring(id.length());
}
}
return handle;
}
/**
* Converts an input handle back to the corresponding java element.
*
* @param project
* the project, or <code>null</code> for the workspace
* @param handle
* the input handle
* @return the corresponding java element, or <code>null</code> if no such
* element exists
*/
public static IJavaElement handleToElement(final String project, final String handle) {
return handleToElement(project, handle, true);
}
/**
* Converts an input handle back to the corresponding java element.
*
* @param project
* the project, or <code>null</code> for the workspace
* @param handle
* the input handle
* @param check
* <code>true</code> to check for existence of the element,
* <code>false</code> otherwise
* @return the corresponding java element, or <code>null</code> if no such
* element exists
*/
public static IJavaElement handleToElement(final String project, final String handle, final boolean check) {
return handleToElement(null, project, handle, check);
}
/**
* Converts an input handle back to the corresponding java element.
*
* @param owner
* the working copy owner
* @param project
* the project, or <code>null</code> for the workspace
* @param handle
* the input handle
* @param check
* <code>true</code> to check for existence of the element,
* <code>false</code> otherwise
* @return the corresponding java element, or <code>null</code> if no such
* element exists
*/
public static IJavaElement handleToElement(final WorkingCopyOwner owner, final String project, final String handle, final boolean check) {
IJavaElement element= null;
if (owner != null)
element= JavaCore.create(handle, owner);
else
element= JavaCore.create(handle);
if (element == null && project != null) {
final IJavaProject javaProject= JavaCore.create(ResourcesPlugin.getWorkspace().getRoot()).getJavaProject(project);
final String identifier= javaProject.getHandleIdentifier();
if (owner != null)
element= JavaCore.create(identifier + handle, owner);
else
element= JavaCore.create(identifier + handle);
}
if (check && element instanceof IMethod) {
/*
* Resolve the method based on simple names of parameter types
* (to accommodate for different qualifications when refactoring is e.g.
* recorded in source but applied on binary method):
*/
final IMethod method= (IMethod) element;
final IMethod[] methods= method.getDeclaringType().findMethods(method);
if (methods != null && methods.length > 0)
element= methods[0];
}
if (element != null && (!check || element.exists()))
return element;
return null;
}
/**
* Converts an input handle with the given prefix back to the corresponding
* resource.
*
* @param project
* the project, or <code>null</code> for the workspace
* @param handle
* the input handle
*
* @return the corresponding resource, or <code>null</code> if no such
* resource exists.
* Note: if the given handle is absolute, the project is not used to resolve.
*/
public static IResource handleToResource(final String project, final String handle) {
final IWorkspaceRoot root= ResourcesPlugin.getWorkspace().getRoot();
if ("".equals(handle)) //$NON-NLS-1$
return null;
final IPath path= Path.fromPortableString(handle);
if (path == null)
return null;
if (project != null && !"".equals(project) && ! path.isAbsolute()) //$NON-NLS-1$
return root.getProject(project).findMember(path);
return root.findMember(path);
}
/**
* Converts the specified resource to an input handle.
*
* @param project
* the project, or <code>null</code> for the workspace
* @param resource
* the resource
*
* @return the input handle.
* Note: if the given project is not the resource's project, then the full handle is returned.
*/
public static String resourceToHandle(final String project, final IResource resource) {
if (project != null && !"".equals(project) && project.equals(resource.getProject().getName())) //$NON-NLS-1$
return resource.getProjectRelativePath().toPortableString();
return resource.getFullPath().toPortableString();
}
/**
* Creates a fatal error status telling that the input element does not
* exist.
*
* @param element
* the input element, or <code>null</code>
* @param name
* the name of the refactoring
* @param id
* the id of the refactoring
* @return the refactoring status
*/
public static RefactoringStatus createInputFatalStatus(final Object element, final String name, final String id) {
Assert.isNotNull(name);
Assert.isNotNull(id);
if (element != null)
return RefactoringStatus.createFatalErrorStatus(Messages.format(RefactoringCoreMessages.InitializableRefactoring_input_not_exists, new String[] { JavaElementLabels.getTextLabel(element, JavaElementLabels.ALL_FULLY_QUALIFIED), name, id}));
else
return RefactoringStatus.createFatalErrorStatus(Messages.format(RefactoringCoreMessages.InitializableRefactoring_inputs_do_not_exist, new String[] { name, id}));
}
/**
* Creates a warning status telling that the input element does not exist.
*
* @param element
* the input element, or <code>null</code>
* @param name
* the name of the refactoring
* @param id
* the id of the refactoring
* @return the refactoring status
*/
public static RefactoringStatus createInputWarningStatus(final Object element, final String name, final String id) {
Assert.isNotNull(name);
Assert.isNotNull(id);
if (element != null)
return RefactoringStatus.createWarningStatus(Messages.format(RefactoringCoreMessages.InitializableRefactoring_input_not_exists, new String[] { JavaElementLabels.getTextLabel(element, JavaElementLabels.ALL_FULLY_QUALIFIED), name, id}));
else
return RefactoringStatus.createWarningStatus(Messages.format(RefactoringCoreMessages.InitializableRefactoring_inputs_do_not_exist, new String[] { name, id}));
}
}